ജാവാസ്ക്രിപ്റ്റിലെ പാറ്റേൺ മാച്ചിംഗ് റെഗുലർ എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ച്: ഒരു സമഗ്രമായ ഗൈഡ്

ജാവാസ്ക്രിപ്റ്റിൽ പാറ്റേൺ മാച്ചിംഗിനും ടെക്സ്റ്റ് മാനിപ്പുലേഷനുമുള്ള ഒരു ശക്തമായ ഉപകരണമാണ് റെഗുലർ എക്സ്പ്രഷനുകൾ (റെജെക്സ്). നിർവചിക്കപ്പെട്ട പാറ്റേണുകളെ അടിസ്ഥാനമാക്കി സ്ട്രിംഗുകൾ തിരയാനും, സാധുത ഉറപ്പാക്കാനും, രൂപാന്തരപ്പെടുത്താനും ഇത് ഡെവലപ്പർമാരെ അനുവദിക്കുന്നു. ഈ ഗൈഡ് ജാവാസ്ക്രിപ്റ്റിലെ റെഗുലർ എക്സ്പ്രഷനുകളെക്കുറിച്ചുള്ള ഒരു സമഗ്രമായ വിവരണം നൽകുന്നു, ഇതിൽ സിന്റാക്സ്, ഉപയോഗം, അഡ്വാൻസ്ഡ് ടെക്നിക്കുകൾ എന്നിവ ഉൾപ്പെടുന്നു.

എന്താണ് റെഗുലർ എക്സ്പ്രഷനുകൾ?

ഒരു റെഗുലർ എക്സ്പ്രഷൻ എന്നത് ഒരു തിരയൽ പാറ്റേൺ നിർവചിക്കുന്ന അക്ഷരങ്ങളുടെ ഒരു ശ്രേണിയാണ്. സ്ട്രിംഗുകൾ പൊരുത്തപ്പെടുത്താനും കൈകാര്യം ചെയ്യാനും ഈ പാറ്റേണുകൾ ഉപയോഗിക്കുന്നു. പ്രോഗ്രാമിംഗിൽ താഴെ പറയുന്ന കാര്യങ്ങൾക്കായി റെഗുലർ എക്സ്പ്രഷനുകൾ വ്യാപകമായി ഉപയോഗിക്കുന്നു:

• ഡാറ്റാ വാലിഡേഷൻ: ഉപയോക്താവിൻ്റെ ഇൻപുട്ട് നിർദ്ദിഷ്ട ഫോർമാറ്റുകൾക്ക് അനുസൃതമാണെന്ന് ഉറപ്പാക്കുന്നു (ഉദാ. ഇമെയിൽ വിലാസങ്ങൾ, ഫോൺ നമ്പറുകൾ).
• ഡാറ്റാ എക്‌സ്‌ട്രാക്ഷൻ: ടെക്സ്റ്റിൽ നിന്ന് നിർദ്ദിഷ്ട വിവരങ്ങൾ വീണ്ടെടുക്കുന്നു (ഉദാ. തീയതികൾ, URL-കൾ, അല്ലെങ്കിൽ വിലകൾ).
• തിരയലും മാറ്റിസ്ഥാപിക്കലും: സങ്കീർണ്ണമായ പാറ്റേണുകളെ അടിസ്ഥാനമാക്കി ടെക്സ്റ്റ് കണ്ടെത്തുകയും മാറ്റിസ്ഥാപിക്കുകയും ചെയ്യുന്നു.
• ടെക്സ്റ്റ് പ്രോസസ്സിംഗ്: നിർവചിക്കപ്പെട്ട നിയമങ്ങളെ അടിസ്ഥാനമാക്കി സ്ട്രിംഗുകൾ വിഭജിക്കുക, സംയോജിപ്പിക്കുക, അല്ലെങ്കിൽ രൂപാന്തരപ്പെടുത്തുക.

ജാവാസ്ക്രിപ്റ്റിൽ റെഗുലർ എക്സ്പ്രഷനുകൾ എങ്ങനെ നിർമ്മിക്കാം

ജാവാസ്ക്രിപ്റ്റിൽ, റെഗുലർ എക്സ്പ്രഷനുകൾ രണ്ട് രീതിയിൽ നിർമ്മിക്കാം:

1. ഒരു റെഗുലർ എക്സ്പ്രഷൻ ലിറ്ററൽ ഉപയോഗിച്ച്: പാറ്റേൺ ഫോർവേഡ് സ്ലാഷുകൾക്കുള്ളിൽ (/) ഉൾപ്പെടുത്തുക.
2. RegExp കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ച്: പാറ്റേൺ ഒരു സ്ട്രിംഗ് ആയി നൽകി ഒരു RegExp ഒബ്ജക്റ്റ് നിർമ്മിക്കുക.

ഉദാഹരണം:

// ഒരു റെഗുലർ എക്സ്പ്രഷൻ ലിറ്ററൽ ഉപയോഗിച്ച്
const regexLiteral = /hello/;

// RegExp കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ച്
const regexConstructor = new RegExp("hello");

ഈ രണ്ട് രീതികളിൽ ഏത് തിരഞ്ഞെടുക്കണം എന്നത് പാറ്റേൺ കംപൈൽ സമയത്ത് അറിയാവുന്നതാണോ അതോ ഡൈനാമിക്കായി ജനറേറ്റ് ചെയ്യുന്നതാണോ എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. പാറ്റേൺ സ്ഥിരവും മുൻകൂട്ടി അറിയാവുന്നതുമാണെങ്കിൽ ലിറ്ററൽ നൊട്ടേഷൻ ഉപയോഗിക്കുക. പാറ്റേൺ പ്രോഗ്രാമാറ്റിക്കായി നിർമ്മിക്കേണ്ടിവരുമ്പോൾ, പ്രത്യേകിച്ച് വേരിയബിളുകൾ ഉൾപ്പെടുത്തുമ്പോൾ, കൺസ്ട്രക്റ്റർ ഉപയോഗിക്കുക.

അടിസ്ഥാന റെജെക്സ് സിന്റാക്സ്

പൊരുത്തപ്പെടുത്തേണ്ട പാറ്റേണിനെ പ്രതിനിധീകരിക്കുന്ന അക്ഷരങ്ങൾ ചേർന്നതാണ് റെഗുലർ എക്സ്പ്രഷനുകൾ. ചില അടിസ്ഥാന റെജെക്സ് ഘടകങ്ങൾ ഇതാ:

• ലിറ്ററൽ ക്യാരക്ടറുകൾ: അക്ഷരങ്ങളെ അതുപോലെ തന്നെ പൊരുത്തപ്പെടുത്തുന്നു (ഉദാ., /a/ 'a' എന്ന അക്ഷരവുമായി പൊരുത്തപ്പെടുന്നു).
• മെറ്റാക്യാരക്ടറുകൾ: പ്രത്യേക അർത്ഥങ്ങളുണ്ട് (ഉദാ., ., ^, $, *, +, ?, [], {}, (), \, |).
• ക്യാരക്ടർ ക്ലാസുകൾ: അക്ഷരങ്ങളുടെ ഗണങ്ങളെ പ്രതിനിധീകരിക്കുന്നു (ഉദാ., [abc] എന്നത് 'a', 'b', അല്ലെങ്കിൽ 'c' യുമായി പൊരുത്തപ്പെടുന്നു).
• ക്വാണ്ടിഫയറുകൾ: ഒരു അക്ഷരമോ ഗ്രൂപ്പോ എത്ര തവണ ആവർത്തിക്കണമെന്ന് വ്യക്തമാക്കുന്നു (ഉദാ., *, +, ?, {n}, {n,}, {n,m}).
• ആങ്കറുകൾ: സ്ട്രിംഗിലെ സ്ഥാനങ്ങളുമായി പൊരുത്തപ്പെടുന്നു (ഉദാ., ^ തുടക്കവുമായും $ അവസാനവുമായും പൊരുത്തപ്പെടുന്നു).

സാധാരണ മെറ്റാക്യാരക്ടറുകൾ:

• . (dot): ന്യൂലൈൻ ഒഴികെയുള്ള ഏതെങ്കിലും ഒരൊറ്റ അക്ഷരവുമായി പൊരുത്തപ്പെടുന്നു.
• ^ (caret): സ്ട്രിംഗിൻ്റെ തുടക്കവുമായി പൊരുത്തപ്പെടുന്നു.
• $ (dollar): സ്ട്രിംഗിൻ്റെ അവസാനവുമായി പൊരുത്തപ്പെടുന്നു.
• * (asterisk): മുൻപുള്ള അക്ഷരമോ ഗ്രൂപ്പോ പൂജ്യമോ അതിലധികമോ തവണ ആവർത്തിക്കുന്നതുമായി പൊരുത്തപ്പെടുന്നു.
• + (plus): മുൻപുള്ള അക്ഷരമോ ഗ്രൂപ്പോ ഒന്നോ അതിലധികമോ തവണ ആവർത്തിക്കുന്നതുമായി പൊരുത്തപ്പെടുന്നു.
• ? (question mark): മുൻപുള്ള അക്ഷരമോ ഗ്രൂപ്പോ പൂജ്യമോ ഒരു തവണയോ ആവർത്തിക്കുന്നതുമായി പൊരുത്തപ്പെടുന്നു. ഓപ്ഷണൽ അക്ഷരങ്ങൾക്കായി ഉപയോഗിക്കുന്നു.
• [] (square brackets): ഒരു ക്യാരക്ടർ ക്ലാസ് നിർവചിക്കുന്നു, ബ്രാക്കറ്റിനുള്ളിലെ ഏതെങ്കിലും ഒരൊറ്റ അക്ഷരവുമായി പൊരുത്തപ്പെടുന്നു.
• {} (curly braces): എത്ര തവണ പൊരുത്തപ്പെടണം എന്ന് വ്യക്തമാക്കുന്നു. {n} കൃത്യം n തവണ, {n,} n അല്ലെങ്കിൽ അതിൽ കൂടുതൽ തവണ, {n,m} n-നും m-നും ഇടയിൽ (ഉൾപ്പെടെ) തവണ പൊരുത്തപ്പെടുന്നു.
• () (parentheses): അക്ഷരങ്ങളെ ഒരുമിച്ച് ഗ്രൂപ്പ് ചെയ്യുകയും പൊരുത്തപ്പെട്ട സബ്സ്ട്രിംഗ് ക്യാപ്‌ചർ ചെയ്യുകയും ചെയ്യുന്നു.
• \ (backslash): മെറ്റാക്യാരക്ടറുകളെ എസ്‌കേപ്പ് ചെയ്യുന്നു, അവയെ അക്ഷരാർത്ഥത്തിൽ പൊരുത്തപ്പെടുത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു.
• | (pipe): ഒരു "or" ഓപ്പറേറ്ററായി പ്രവർത്തിക്കുന്നു, അതിന് മുൻപോ ശേഷമോ ഉള്ള എക്സ്പ്രഷനുമായി പൊരുത്തപ്പെടുന്നു.

ക്യാരക്ടർ ക്ലാസുകൾ:

• [abc]: a, b, അല്ലെങ്കിൽ c എന്നീ അക്ഷരങ്ങളിൽ ഏതെങ്കിലും ഒന്നുമായി പൊരുത്തപ്പെടുന്നു.
• [^abc]: a, b, അല്ലെങ്കിൽ c അല്ലാത്ത ഏതൊരു അക്ഷരവുമായും പൊരുത്തപ്പെടുന്നു.
• [a-z]: a മുതൽ z വരെയുള്ള ഏതെങ്കിലും ചെറിയക്ഷരവുമായി പൊരുത്തപ്പെടുന്നു.
• [A-Z]: A മുതൽ Z വരെയുള്ള ഏതെങ്കിലും വലിയക്ഷരവുമായി പൊരുത്തപ്പെടുന്നു.
• [0-9]: 0 മുതൽ 9 വരെയുള്ള ഏതെങ്കിലും അക്കവുമായി പൊരുത്തപ്പെടുന്നു.
• [a-zA-Z0-9]: ഏതെങ്കിലും ആൽഫാന്യൂമെറിക് അക്ഷരവുമായി പൊരുത്തപ്പെടുന്നു.
• \d: ഏതെങ്കിലും അക്കവുമായി പൊരുത്തപ്പെടുന്നു ([0-9] ന് തുല്യം).
• \D: അക്കമല്ലാത്ത ഏതൊരു അക്ഷരവുമായും പൊരുത്തപ്പെടുന്നു ([^0-9] ന് തുല്യം).
• \w: ഏതെങ്കിലും വേർഡ് ക്യാരക്ടറുമായി പൊരുത്തപ്പെടുന്നു (ആൽഫാന്യൂമെറിക്, അടിവര; [a-zA-Z0-9_] ന് തുല്യം).
• \W: വേർഡ് ക്യാരക്ടർ അല്ലാത്ത ഏതൊരു അക്ഷരവുമായും പൊരുത്തപ്പെടുന്നു ([^a-zA-Z0-9_] ന് തുല്യം).
• \s: ഏതെങ്കിലും വൈറ്റ്‌സ്‌പെയ്‌സ് ക്യാരക്ടറുമായി പൊരുത്തപ്പെടുന്നു (സ്പേസ്, ടാബ്, ന്യൂലൈൻ, മുതലായവ).
• \S: വൈറ്റ്‌സ്‌പെയ്‌സ് അല്ലാത്ത ഏതൊരു അക്ഷരവുമായും പൊരുത്തപ്പെടുന്നു.

ക്വാണ്ടിഫയറുകൾ:

• *: മുൻപുള്ള ഘടകവുമായി പൂജ്യമോ അതിലധികമോ തവണ പൊരുത്തപ്പെടുന്നു. ഉദാഹരണത്തിന്, a* എന്നത് "", "a", "aa", "aaa", എന്നിങ്ങനെയുള്ളവയുമായി പൊരുത്തപ്പെടുന്നു.
• +: മുൻപുള്ള ഘടകവുമായി ഒന്നോ അതിലധികമോ തവണ പൊരുത്തപ്പെടുന്നു. ഉദാഹരണത്തിന്, a+ എന്നത് "a", "aa", "aaa" എന്നിവയുമായി പൊരുത്തപ്പെടുന്നു, പക്ഷേ "" യുമായി പൊരുത്തപ്പെടുന്നില്ല.
• ?: മുൻപുള്ള ഘടകവുമായി പൂജ്യമോ ഒരു തവണയോ പൊരുത്തപ്പെടുന്നു. ഉദാഹരണത്തിന്, a? എന്നത് "" അല്ലെങ്കിൽ "a" യുമായി പൊരുത്തപ്പെടുന്നു.
• {n}: മുൻപുള്ള ഘടകവുമായി കൃത്യം *n* തവണ പൊരുത്തപ്പെടുന്നു. ഉദാഹരണത്തിന്, a{3} എന്നത് "aaa" യുമായി പൊരുത്തപ്പെടുന്നു.
• {n,}: മുൻപുള്ള ഘടകവുമായി *n* അല്ലെങ്കിൽ അതിൽ കൂടുതൽ തവണ പൊരുത്തപ്പെടുന്നു. ഉദാഹരണത്തിന്, a{2,} എന്നത് "aa", "aaa", "aaaa", എന്നിങ്ങനെയുള്ളവയുമായി പൊരുത്തപ്പെടുന്നു.
• {n,m}: മുൻപുള്ള ഘടകവുമായി *n* നും *m* നും ഇടയിൽ (ഉൾപ്പെടെ) തവണ പൊരുത്തപ്പെടുന്നു. ഉദാഹരണത്തിന്, a{2,4} എന്നത് "aa", "aaa", അല്ലെങ്കിൽ "aaaa" യുമായി പൊരുത്തപ്പെടുന്നു.

ആങ്കറുകൾ:

• ^: സ്ട്രിംഗിൻ്റെ തുടക്കവുമായി പൊരുത്തപ്പെടുന്നു. ഉദാഹരണത്തിന്, ^Hello എന്നത് "Hello" യിൽ *തുടങ്ങുന്ന* സ്ട്രിംഗുകളുമായി പൊരുത്തപ്പെടുന്നു.
• $: സ്ട്രിംഗിൻ്റെ അവസാനവുമായി പൊരുത്തപ്പെടുന്നു. ഉദാഹരണത്തിന്, World$ എന്നത് "World" ൽ *അവസാനിക്കുന്ന* സ്ട്രിംഗുകളുമായി പൊരുത്തപ്പെടുന്നു.
• \b: ഒരു വാക്കിൻ്റെ അതിർത്തിയുമായി പൊരുത്തപ്പെടുന്നു. ഇത് ഒരു വേർഡ് ക്യാരക്ടറിനും (\w) ഒരു നോൺ-വേർഡ് ക്യാരക്ടറിനും (\W) ഇടയിലുള്ള സ്ഥാനമാണ്, അല്ലെങ്കിൽ സ്ട്രിംഗിൻ്റെ തുടക്കമോ അവസാനമോ ആണ്. ഉദാഹരണത്തിന്, \bword\b എന്നത് "word" എന്ന മുഴുവൻ വാക്കുമായി പൊരുത്തപ്പെടുന്നു.

ഫ്ലാഗുകൾ:

റെജെക്സ് ഫ്ലാഗുകൾ റെഗുലർ എക്സ്പ്രഷനുകളുടെ സ്വഭാവം മാറ്റുന്നു. അവ റെജെക്സ് ലിറ്ററലിൻ്റെ അവസാനത്തിൽ ചേർക്കുകയോ RegExp കൺസ്ട്രക്റ്ററിന് രണ്ടാമത്തെ ആർഗ്യുമെന്റായി നൽകുകയോ ചെയ്യുന്നു.

• g (global): പാറ്റേണിൻ്റെ ആദ്യത്തേത് മാത്രമല്ല, എല്ലാ പൊരുത്തങ്ങളെയും കണ്ടെത്തുന്നു.
• i (ignore case): കേസ്-ഇൻസെൻസിറ്റീവ് മാച്ചിംഗ് നടത്തുന്നു.
• m (multiline): മൾട്ടിലൈൻ മോഡ് പ്രവർത്തനക്ഷമമാക്കുന്നു, ഇവിടെ ^ ഉം $ ഉം ഓരോ വരിയുടെയും (\n കൊണ്ട് വേർതിരിച്ചത്) തുടക്കവുമായും അവസാനവുമായും പൊരുത്തപ്പെടുന്നു.
• s (dotAll): ഡോട്ടിനെ (.) ന്യൂലൈൻ അക്ഷരങ്ങളുമായി പൊരുത്തപ്പെടാൻ അനുവദിക്കുന്നു.
• u (unicode): പൂർണ്ണ യൂണികോഡ് പിന്തുണ പ്രവർത്തനക്ഷമമാക്കുന്നു.
• y (sticky): റെജെക്സിൻ്റെ lastIndex പ്രോപ്പർട്ടി സൂചിപ്പിക്കുന്ന ഇൻഡെക്സിൽ നിന്ന് മാത്രം പൊരുത്തപ്പെടുന്നു.

ജാവാസ്ക്രിപ്റ്റ് റെജെക്സ് മെത്തേഡുകൾ

ജാവാസ്ക്രിപ്റ്റ് റെഗുലർ എക്സ്പ്രഷനുകളുമായി പ്രവർത്തിക്കാൻ നിരവധി മെത്തേഡുകൾ നൽകുന്നു:

• test(): ഒരു സ്ട്രിംഗ് പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ എന്ന് പരിശോധിക്കുന്നു. true അല്ലെങ്കിൽ false നൽകുന്നു.
• exec(): ഒരു സ്ട്രിംഗിൽ പൊരുത്തത്തിനായി തിരച്ചിൽ നടത്തുന്നു. പൊരുത്തപ്പെട്ട ടെക്സ്റ്റും ക്യാപ്‌ചർ ചെയ്ത ഗ്രൂപ്പുകളും അടങ്ങുന്ന ഒരു അറേ നൽകുന്നു, അല്ലെങ്കിൽ പൊരുത്തം കണ്ടെത്തിയില്ലെങ്കിൽ null നൽകുന്നു.
• match(): ഒരു റെഗുലർ എക്സ്പ്രഷനുമായി ഒരു സ്ട്രിംഗിനെ പൊരുത്തപ്പെടുത്തിയതിൻ്റെ ഫലങ്ങൾ അടങ്ങിയ ഒരു അറേ നൽകുന്നു. g ഫ്ലാഗിനൊപ്പവും അല്ലാതെയും വ്യത്യസ്തമായി പ്രവർത്തിക്കുന്നു.
• search(): ഒരു സ്ട്രിംഗിൽ പൊരുത്തത്തിനായി പരിശോധിക്കുന്നു. ആദ്യ പൊരുത്തത്തിൻ്റെ ഇൻഡെക്സ് നൽകുന്നു, അല്ലെങ്കിൽ പൊരുത്തം കണ്ടെത്തിയില്ലെങ്കിൽ -1 നൽകുന്നു.
• replace(): ഒരു പാറ്റേണിൻ്റെ സംഭവങ്ങളെ ഒരു റീപ്ലേസ്‌മെൻ്റ് സ്ട്രിംഗ് ഉപയോഗിച്ചോ അല്ലെങ്കിൽ റീപ്ലേസ്‌മെൻ്റ് സ്ട്രിംഗ് നൽകുന്ന ഒരു ഫംഗ്ഷൻ ഉപയോഗിച്ചോ മാറ്റിസ്ഥാപിക്കുന്നു.
• split(): ഒരു റെഗുലർ എക്സ്പ്രഷനെ അടിസ്ഥാനമാക്കി ഒരു സ്ട്രിംഗിനെ സബ്സ്ട്രിംഗുകളുടെ ഒരു അറേയിലേക്ക് വിഭജിക്കുന്നു.

റെജെക്സ് മെത്തേഡുകൾ ഉപയോഗിച്ചുള്ള ഉദാഹരണങ്ങൾ:

// test()
const regex = /hello/;
const str = "hello world";
console.log(regex.test(str)); // ഔട്ട്‌പുട്ട്: true

// exec()
const regex2 = /hello (\w+)/;
const str2 = "hello world";
const result = regex2.exec(str2);
console.log(result); // ഔട്ട്‌പുട്ട്: ["hello world", "world", index: 0, input: "hello world", groups: undefined]

// 'g' ഫ്ലാഗോടുകൂടിയ match()
const regex3 = /\d+/g; // ഒന്നോ അതിലധികമോ അക്കങ്ങളെ ഗ്ലോബലായി പൊരുത്തപ്പെടുത്തുന്നു
const str3 = "There are 123 apples and 456 oranges.";
const matches = str3.match(regex3);
console.log(matches); // ഔട്ട്‌പുട്ട്: ["123", "456"]

// 'g' ഫ്ലാഗില്ലാതെ match()
const regex4 = /\d+/;
const str4 = "There are 123 apples and 456 oranges.";
const match = str4.match(regex4);
console.log(match); // ഔട്ട്‌പുട്ട്: ["123", index: 11, input: "There are 123 apples and 456 oranges.", groups: undefined]

// search()
const regex5 = /world/;
const str5 = "hello world";
console.log(str5.search(regex5)); // ഔട്ട്‌പുട്ട്: 6

// replace()
const regex6 = /world/;
const str6 = "hello world";
const newStr = str6.replace(regex6, "JavaScript");
console.log(newStr); // ഔട്ട്‌പുട്ട്: hello JavaScript

// ഒരു ഫംഗ്ഷൻ ഉപയോഗിച്ച് replace()
const regex7 = /(\d+)-(\d+)-(\d+)/;
const str7 = "Today's date is 2023-10-27";
const newStr2 = str7.replace(regex7, (match, year, month, day) => {
  return `${day}/${month}/${year}`;
});
console.log(newStr2); // ഔട്ട്‌പുട്ട്: Today's date is 27/10/2023

// split()
const regex8 = /, /;
const str8 = "apple, banana, cherry";
const arr = str8.split(regex8);
console.log(arr); // ഔട്ട്‌പുട്ട്: ["apple", "banana", "cherry"]

അഡ്വാൻസ്ഡ് റെജെക്സ് ടെക്നിക്കുകൾ

ക്യാപ്‌ചറിംഗ് ഗ്രൂപ്പുകൾ:

റെഗുലർ എക്സ്പ്രഷനുകളിൽ ക്യാപ്‌ചറിംഗ് ഗ്രൂപ്പുകൾ ഉണ്ടാക്കാൻ പാരെന്തെസിസ് () ഉപയോഗിക്കുന്നു. ക്യാപ്‌ചർ ചെയ്ത ഗ്രൂപ്പുകൾ പൊരുത്തപ്പെട്ട ടെക്സ്റ്റിൻ്റെ നിർദ്ദിഷ്ട ഭാഗങ്ങൾ എക്‌സ്‌ട്രാക്റ്റുചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. exec(), match() എന്നീ മെത്തേഡുകൾ നൽകുന്ന അറേയിൽ ആദ്യത്തെ എലമെൻ്റ് മുഴുവൻ മാച്ചും തുടർന്നുള്ളവ ക്യാപ്‌ചർ ചെയ്ത ഗ്രൂപ്പുകളുമായിരിക്കും.

const regex = /(\d{4})-(\d{2})-(\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);

console.log(match[0]); // ഔട്ട്‌പുട്ട്: 2023-10-27 (മുഴുവൻ മാച്ച്)
console.log(match[1]); // ഔട്ട്‌പുട്ട്: 2023 (ആദ്യത്തെ ക്യാപ്‌ചർ ചെയ്ത ഗ്രൂപ്പ് - വർഷം)
console.log(match[2]); // ഔട്ട്‌പുട്ട്: 10 (രണ്ടാമത്തെ ക്യാപ്‌ചർ ചെയ്ത ഗ്രൂപ്പ് - മാസം)
console.log(match[3]); // ഔട്ട്‌പുട്ട്: 27 (മൂന്നാമത്തെ ക്യാപ്‌ചർ ചെയ്ത ഗ്രൂപ്പ് - ദിവസം)

പേരുള്ള ക്യാപ്‌ചറിംഗ് ഗ്രൂപ്പുകൾ:

ES2018-ൽ പേരുള്ള ക്യാപ്‌ചറിംഗ് ഗ്രൂപ്പുകൾ അവതരിപ്പിച്ചു, ഇത് (?...) എന്ന സിന്റാക്സ് ഉപയോഗിച്ച് ക്യാപ്‌ചറിംഗ് ഗ്രൂപ്പുകൾക്ക് പേരുകൾ നൽകാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് കോഡ് കൂടുതൽ വായിക്കാനും പരിപാലിക്കാനും എളുപ്പമാക്കുന്നു.

const regex = /(?\d{4})-(?\d{2})-(?\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);

console.log(match.groups.year);  // ഔട്ട്‌പുട്ട്: 2023
console.log(match.groups.month); // ഔട്ട്‌പുട്ട്: 10
console.log(match.groups.day);   // ഔട്ട്‌പുട്ട്: 27

നോൺ-ക്യാപ്‌ചറിംഗ് ഗ്രൂപ്പുകൾ:

ഒരു റെജെക്സിൻ്റെ ഭാഗങ്ങൾ ക്യാപ്‌ചർ ചെയ്യാതെ ഗ്രൂപ്പ് ചെയ്യണമെങ്കിൽ (ഉദാഹരണത്തിന്, ഒരു ഗ്രൂപ്പിൽ ക്വാണ്ടിഫയർ പ്രയോഗിക്കാൻ), നിങ്ങൾക്ക് (?:...) എന്ന സിന്റാക്സ് ഉപയോഗിച്ച് ഒരു നോൺ-ക്യാപ്‌ചറിംഗ് ഗ്രൂപ്പ് ഉപയോഗിക്കാം. ഇത് ക്യാപ്‌ചർ ചെയ്ത ഗ്രൂപ്പുകൾക്കായി അനാവശ്യ മെമ്മറി അനുവദിക്കുന്നത് ഒഴിവാക്കുന്നു.

const regex = /(?:https?:\/\/)?([\w\.]+)/; // ഒരു URL-മായി പൊരുത്തപ്പെടുന്നു, പക്ഷേ ഡൊമെയ്ൻ നാമം മാത്രം ക്യാപ്‌ചർ ചെയ്യുന്നു
const url = "https://www.example.com/path";
const match = regex.exec(url);

console.log(match[1]); // ഔട്ട്‌പുട്ട്: www.example.com

ലുക്ക്എറൗണ്ട്സ്:

ലുക്ക്എറൗണ്ടുകൾ സീറോ-വിഡ്ത്ത് അസെർഷനുകളാണ്, അത് ഒരു സ്ട്രിംഗിലെ ഒരു സ്ഥാനത്തെ, ആ സ്ഥാനത്തിന് മുമ്പോ ശേഷമോ വരുന്ന ഒരു പാറ്റേണിനെ അടിസ്ഥാനമാക്കി പൊരുത്തപ്പെടുത്തുന്നു, എന്നാൽ ലുക്ക്എറൗണ്ട് പാറ്റേൺ മാച്ചിൽ ഉൾപ്പെടുന്നില്ല.

• പോസിറ്റീവ് ലുക്ക്എഹെഡ്: (?=...) ലുക്ക്എഹെഡിനുള്ളിലെ പാറ്റേൺ നിലവിലെ സ്ഥാനത്തെ *പിന്തുടരുന്നുവെങ്കിൽ* പൊരുത്തപ്പെടുന്നു.
• നെഗറ്റീവ് ലുക്ക്എഹെഡ്: (?!...) ലുക്ക്എഹെഡിനുള്ളിലെ പാറ്റേൺ നിലവിലെ സ്ഥാനത്തെ *പിന്തുടരുന്നില്ലെങ്കിൽ* പൊരുത്തപ്പെടുന്നു.
• പോസിറ്റീവ് ലുക്ക്ബിഹൈൻഡ്: (?<=...) ലുക്ക്ബിഹൈൻഡിനുള്ളിലെ പാറ്റേൺ നിലവിലെ സ്ഥാനത്തിന് *മുമ്പാണെങ്കിൽ* പൊരുത്തപ്പെടുന്നു.
• നെഗറ്റീവ് ലുക്ക്ബിഹൈൻഡ്: (? ലുക്ക്ബിഹൈൻഡിനുള്ളിലെ പാറ്റേൺ നിലവിലെ സ്ഥാനത്തിന് *മുമ്പല്ലെങ്കിൽ* പൊരുത്തപ്പെടുന്നു.

// പോസിറ്റീവ് ലുക്ക്എഹെഡ്: USD പിന്തുടരുമ്പോൾ മാത്രം വില നേടുക
const regex = /\d+(?= USD)/;
const text = "The price is 100 USD";
const match = text.match(regex);
console.log(match); // ഔട്ട്‌പുട്ട്: ["100"]

// നെഗറ്റീവ് ലുക്ക്എഹെഡ്: ഒരു നമ്പർ പിന്തുടരാത്തപ്പോൾ മാത്രം വാക്ക് നേടുക
const regex2 = /\b\w+\b(?! \d)/;
const text2 = "apple 123 banana orange 456";
const matches = text2.match(regex2);
console.log(matches); // ഔട്ട്‌പുട്ട്: null കാരണം 'g' ഫ്ലാഗില്ലാതെ match() ആദ്യ മാച്ച് മാത്രമേ നൽകൂ, അത് നമുക്ക് വേണ്ടതല്ല.
// ഇത് പരിഹരിക്കാൻ:
const regex3 = /\b\w+\b(?! \d)/g;
const text3 = "apple 123 banana orange 456";
const matches3 = text3.match(regex3);
console.log(matches3); // ഔട്ട്‌പുട്ട്: [ 'banana' ]

// പോസിറ്റീവ് ലുക്ക്ബിഹൈൻഡ്: $-ന് മുമ്പാണെങ്കിൽ മാത്രം മൂല്യം നേടുക
const regex4 = /(?<=\$)\d+/;
const text4 = "The price is $200";
const match4 = text4.match(regex4);
console.log(match4); // ഔട്ട്‌പുട്ട്: ["200"]

// നെഗറ്റീവ് ലുക്ക്ബിഹൈൻഡ്: 'not' എന്ന വാക്കിന് മുമ്പല്ലെങ്കിൽ മാത്രം വാക്ക് നേടുക
const regex5 = /(?

const regex = /([a-z]+) \1/;
const text = "hello hello world";
const match = regex.exec(text);
console.log(match); // ഔട്ട്‌പുട്ട്: ["hello hello", "hello", index: 0, input: "hello hello world", groups: undefined]

const emailRegex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/;

console.log(emailRegex.test("test@example.com"));    // ഔട്ട്‌പുട്ട്: true
console.log(emailRegex.test("invalid-email"));       // ഔട്ട്‌പുട്ട്: false
console.log(emailRegex.test("test@sub.example.co.uk")); // ഔട്ട്‌പുട്ട്: true

const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/g;
const text = "Visit our website at https://www.example.com or check out http://blog.example.org.";
const urls = text.match(urlRegex);
console.log(urls); // ഔട്ട്‌പുട്ട്: ["https://www.example.com", "http://blog.example.org"]

const csvString = 'John,Doe,"123, Main St",New York';
const csvRegex = /(?:"([^"]*(?:""[^"]*)*)")|([^,]+)/g; // ശരിയാക്കിയ CSV റെജെക്സ്
let values = [];
let match;  

while (match = csvRegex.exec(csvString)) {
  values.push(match[1] ? match[1].replace(/""/g, '"') : match[2]);
}


console.log(values); // ഔട്ട്‌പുട്ട്: ["John", "Doe", "123, Main St", "New York"]

const phoneRegex = /^\+(?:[0-9] ?){6,14}[0-9]$/;
console.log(phoneRegex.test("+1 555 123 4567")); // ഔട്ട്‌പുട്ട്: true (യുഎസ് ഉദാഹരണം)
console.log(phoneRegex.test("+44 20 7946 0500")); // ഔട്ട്‌പുട്ട്: true (യുകെ ഉദാഹരണം)
console.log(phoneRegex.test("+81 3 3224 5000"));  // ഔട്ട്‌പുട്ട്: true (ജപ്പാൻ ഉദാഹരണം)
console.log(phoneRegex.test("123-456-7890"));   // ഔട്ട്‌പുട്ട്: false

const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/;

console.log(passwordRegex.test("P@ssword123")); // ഔട്ട്‌പുട്ട്: true
console.log(passwordRegex.test("password"));       // ഔട്ട്‌പുട്ട്: false (വലിയക്ഷരമോ സംഖ്യയോ ഇല്ല)
console.log(passwordRegex.test("Password"));       // ഔട്ട്‌പുട്ട്: false (സംഖ്യ ഇല്ല)
console.log(passwordRegex.test("Pass123"));        // ഔട്ട്‌പുട്ട്: false (ചെറിയക്ഷരം ഇല്ല)
console.log(passwordRegex.test("P@ss1"));          // ഔട്ട്‌പുട്ട്: false (8 അക്ഷരങ്ങളിൽ കുറവ്)